#include<iostream>
using namespace std;

// class A
// {
// public:
//     // func就是虚函数
//     virtual void func()
//     {
//         // ...
//     }
// };


// // 人
// class Person
// {
// protected:
//     double _price; // 票价
// public:
//     // 返回票价
//     virtual double ticket_price() 
//     { 
//         cout << "基类: 原价" << endl;
//         return _price;
//     }
// };

// // 学生，继承Person，便于复用Person的成员
// class Student : public Person
// {
// public:
//     // 学生买票打七折，其结果应当与Person的不同，因此我写了一个与Person同名的返回票价的函数
//     void ticket_price()
//     { 
//         cout << "学生: 打七折" << endl;
//         // return _price * 0.7;
//     }
// };

// // 儿童，继承Person，便于复用Person的成员
// class Child : public Person
// {
// public:
//     // 儿童买票打五折，其结果应当与Person的不同，因此我写了一个与Person同名的返回票价的函数
//     virtual double ticket_price()
//     { 
//         cout << "儿童: 打5折" << endl;
//         return _price * 0.5; 
//     }
// };

// void func(Person* p)
// {
//     p->ticket_price();
// }

// int main()
// {
//     Person p1;
//     func(&p1);

//     Student s1;
//     func(&s1);

//     Child c1;
//     func(&c1);
//     return 0;
// }

// void func(Person& p)
// {
//     p.ticket_price();
// }

// int main()
// {
//     Person p1;
//     func(p1);

//     Student s1;
//     func(s1);

//     Child c1;
//     func(c1);
//     return 0;
// }


// class Person
// {
// protected:
//     double _price; // 票价
// public:
//     // 返回票价
//     virtual double ticket_price() 
//     { 
//         cout << "基类: 原价" << endl;
//         return _price;
//     }
// };

// // 学生
// class Student : public Person
// {
// public:
//     virtual double ticket_price() 
//     { 
//         cout << "学生: 打七折" << endl;
//         return _price * 0.7;
//     }
// };

// // 社会人士
// class Social_person : public Person
// {
// public:
//     virtual double ticket_price() 
//     { 
//         cout << "社会人士: 原价" << endl;
//         return _price; 
//     }
// };

// void func(Person& p)
// {
//     p.ticket_price();
// }

// int main()
// {
//     Student s1;
//     s1.ticket_price();
//     func(s1);

//     cout << "---------" << endl;
    
//     Social_person sp1;
//     sp1.ticket_price();
//     func(sp1);

//     return 0;
// }

// class A
// {
// protected:
//     int _a;
// public:
//     virtual ~A() { cout << "~A()" << endl; }
// };

// class B : public A
// {
// protected:
//     int* _ptr;
// public:
//     B() 
//         :_ptr(new int[10])
//     {
//         cout << "申请内存" << endl;
//     }
//     virtual ~B() 
//     { 
//         delete[] _ptr;
//         cout << "释放内存" << endl;
//         cout << "~B()" << endl; 
//     }
// };

// int main()
// {
//     A* pb = new B;
//     delete pb;
//     return 0;
// }

// class A final
// {
// public:
//     virtual void func(int i)   // 基类虚函数
//     {
//         // ...
//     }
// };

// class B : public A
// {};


// class Person
// {};

// class Student : public Person
// {};

// class A
// {
// protected:
//     int _a;
// public:
//     virtual Person* func() // 返回值为父类的引用
//     {
//         cout << "A: func()" << endl;
//         return new Person;
//     }
// };

// class B : public A
// {
// public:
//     virtual Student* func()	// 返回值为子类的引用
//     {
//         cout << "B: func()" << endl;
//         return new Student;
//     }
// };

// int main()
// {
//     A* pa = new A;
//     A* pb = new B;
//     pa->func();
//     pb->func();
//     return 0;
// }

// class A
// {
// public:
//     int func(int a = 10)
//     {
//         cout << "A::func(int a = 10)" << endl;
//         return a;
//     }
// };

// class B : public A
// {
// public:
//     int func()
//     {
//         cout << "B::func()" << endl;
//         return 0;
//     }

//     // 类内调用func
//     void call_func()
//     {
//         func();     // 调用B类的func
//         A::func();  // 调用A类的func
//     }
// };

// int main()
// {
//     B b1;
//     b1.call_func();
//     cout << endl;
//     // 类外调用func
//     b1.func();      // 调用B类的func
//     b1.A::func();   // 调用A类的func
// }

// int main()
// {
//     B b1;
//     b1.func();

//     A& ref = b1;
//     ref.func();

//     A* ptr = &b1;
//     ptr->func();
//     return 0;
// }

// virtual void func() = 0;

// class A
// {
// public:
//     virtual void func() = 0;
// };

// class B : public A
// {};

// class C : public B
// {};
// int main()
// {
//     A a; // err 抽象类不能实例化对象
//     B b; // err 继承抽象类，没有重写纯虚函数
//     C c;
//     return 0;
// }

// class A
// {
// public:
//     virtual int func(int a = 10)
//     {
//         cout << "A::func(int a = 10) ->" << a << endl;
//         return a;
//     }
// };

// class B : public A
// {
// // 将func函数的访问权限改为private
// private:
//     virtual int func(int a = 999) // B类func的返回值、参数列表都与A类的func相同，构成重写
//     {
//         cout << "B::func(int a = 999) ->" << a << endl;
//         return a;
//     }
// };

// int main()
// {
//     B b1;
//     // b1.func(); //err 用对象无法调用调用

//     // 多态可以调用
//     A& ref = b1;	
//     ref.func();	// 即使B类的func是私有，多态调用时还是按父类func的访问权限

//     A* ptr = &b1;
//     ptr->func();
//     return 0;
// }

// class Base
// {
// protected:
//     int _a;
//     char _c;
// public:
//     virtual void func()
//     {
//         cout << "void func()" << endl;
//     }
//     virtual void func1()
//     {
//         cout << "void func1()" << endl;
//     }
//     virtual void func2()
//     {
//         cout << "void fun22)" << endl;
//     }
// };

// int main()
// {
//     Base b1;
//     cout << sizeof(Base) << endl;
//     cout << sizeof(b1) << endl;
//     return 0;
// }

// class Base
// {
// protected:
//     int _a;
//     char _c;
// public:
// 	// func与func1是虚函数，func2不是
//     virtual void func() { cout << "Base: func()" << endl; }
// 	virtual void func1() { cout << "Base: func1()" << endl; }
// 	void func2() { cout << "Base: func2()" << endl; }
// };

// class Derive : public Base
// {
// public:
//     virtual void func() { cout << "Derive: func()" << endl; }
// };

// int main()
// {
//     int val;
//     int* ptr = new int;
//     static int s_val;
//     const char* s = "12345";
//     printf("栈区:   %p\n", &val);
//     printf("堆区:   %p\n", ptr);
//     printf("静态区: %p\n", &s_val);
//     printf("常量区: %p\n", s);

// 	Base b;
// 	Derive d;
// 	printf("Base的虚表:  %p\n", *((int*)&b));
// 	printf("Derive的虚表:%p\n", *((int*)&d));

//     return 0;
// }

// class Base1
// {
// protected:
//     int _b1;
// };

// class Base2
// {
// protected:
//     int _b2;
// };

// class Derive : public Base1, public Base2
// {
// protected:
//     int _d;
// };

// int main()
// {
//     Derive d;
//     Base1* p1 = &d;
//     Base2* p2 = &d;
//     Derive* p3 = &d;
//     printf("p1: %p\n", p1);
//     printf("p2: %p\n", p2);
//     printf("p3: %p\n", p3);
//     return 0;
// }

// class A
// {
// public:
//     ~A() { cout << "~A()" << endl; }
//     // destructor() { cout << "destructor" << endl; }
// };

// int main()
// {
//     A a;
//     return 0;
// }


class A{
public:
    A(char *s) { cout<<s<<endl; } 
    ~A(){}
};
class B:virtual public A
{
public:
    B(char *s1,char*s2):A(s1) { cout<<s2<<endl; }
};
class C:virtual public A
{
public:
    C(char *s1,char*s2):A(s1) { cout<<s2<<endl; }
};
class D:public B,public C
{
public:
    D(char *s1,char *s2,char *s3,char *s4):B(s1,s2),C(s1,s3),A(s1)
    { cout<<s4<<endl;} 
};
int main() {
    D *p=new D("class A","class B","class C","class D");
    delete p;
    return 0;
}
// A D C A X
// AD D 